Refactor shortestPathSearch to Parallel Delta-Stepping - #211

sequenceDiagram
    participant Caller as MapData_shortestPathSearch
    participant Map as Map
    participant ThreadUtils as thread_utils
    participant Worker as WorkerThread
    participant ShardArr as Shard_array
    participant Recipient as ShortestPathRecipient

    Caller->>Map: getRooms()
    Map-->>Caller: ImmRoomIdSet
    Caller->>Map: getRooms().last()
    Map-->>Caller: max_room_id
    Caller->>ThreadUtils: idealThreadCount()
    ThreadUtils-->>Caller: numThreads

    loop for each bucket_index
        alt bucket not empty
            Caller->>ThreadUtils: parallel_for_each_tl(light_nodes, ProgressCounter, relax_light, merge)
            par for each WorkerThread on light edges
                ThreadUtils->>Worker: dispatch u_id
                Worker->>Map: getRoomHandle(u_id)
                Worker->>Map: getExit(dir)
                Worker->>Caller: getLength(exit, u_handle, v_handle)
                Worker->>Caller: relax(v_id, new_dist, u_id, dir, dists, parents, lastdirs, locks, max_dist)
                alt new_dist < dists[v]
                    Worker->>ShardArr: lock shard[v % SHARDS]
                    Worker->>Caller: update dists[v], parents[v], lastdirs[v]
                    Worker-->>ShardArr: unlock shard[v % SHARDS]
                end
            and merge thread locals
                ThreadUtils-->>Caller: all_improved_light
            end

            Caller->>ThreadUtils: parallel_for_each_tl(bucket_nodes, ProgressCounter, relax_heavy, merge)
            par for each WorkerThread on heavy edges
                ThreadUtils->>Worker: dispatch u_id
                Worker->>Map: getRoomHandle(u_id)
                Worker->>Map: getExit(dir)
                Worker->>Caller: getLength(exit, u_handle, v_handle)
                Worker->>Caller: relax(v_id, new_dist, u_id, dir, dists, parents, lastdirs, locks, max_dist)
                alt new_dist < dists[v]
                    Worker->>ShardArr: lock shard[v % SHARDS]
                    Worker->>Caller: update dists[v], parents[v], lastdirs[v]
                    Worker-->>ShardArr: unlock shard[v % SHARDS]
                end
            and merge thread locals
                ThreadUtils-->>Caller: all_improved_heavy
            end

            Caller->>Caller: find targets_in_bucket and sort by dist
            loop for each target in targets_in_bucket
                Caller->>Caller: reconstruct path via parents and lastdirs
                Caller->>Recipient: receiveShortestPath(map, result)
            end
        else bucket empty
            Caller->>Caller: advance to next bucket_index
        end
    end

classDiagram
    class MapData {
        +shortestPathSearch(origin : RoomHandle, targets : RoomIdSet, recipient : ShortestPathRecipient, max_hits : int, max_dist : double) void
    }

    class ShortestPathRecipient {
        <<interface>>
        +receiveShortestPath(map : Map, result : ShortestPathResult) void
        +~ShortestPathRecipient() void
    }

    class ShortestPathResult {
        +id : RoomId
        +dist : double
        +path : vector~ExitDirEnum~
    }

    class Shard {
        +mutex : mutex
    }

    class thread_utils {
        +idealThreadCount() size_t
        +parallel_for_each_tl_range(ThreadLocals, Container, ProgressCounter, Callback, MergeThreadLocals) void
        +parallel_for_each_tl(ThreadLocals, Container, ProgressCounter, Callback, MergeThreadLocals) void
    }

    class ProgressCounter {
    }

    class RoomId {
        +asUint32() uint32_t
    }

    class Map {
        +getRooms() ImmRoomIdSet
        +getRoomHandle(id : RoomId) RoomHandle
    }

    class ImmRoomIdSet {
        +last() RoomId
    }

    class RoomHandle {
        +getId() RoomId
        +getExit(dir : ExitDirEnum) RawExit
    }

    class RawExit {
        +outIsUnique() bool
        +exitIsExit() bool
        +getOutgoingSet() RoomIdSet
    }

    class RoomIdSet {
        +first() RoomId
    }

    class ExitDirEnum {
    }

    MapData --> Map : uses
    MapData --> Shard : uses
    MapData --> ShortestPathRecipient : notifies
    MapData --> ShortestPathResult : constructs
    MapData --> thread_utils : uses
    MapData --> ProgressCounter : uses
    MapData --> RoomId : uses
    MapData --> RoomHandle : uses
    MapData --> RawExit : uses

    ShortestPathResult --> RoomId : has
    ShortestPathResult --> ExitDirEnum : path elements

    Map --> ImmRoomIdSet : owns
    Map --> RoomHandle : returns

    ImmRoomIdSet --> RoomId : returns

    RoomHandle --> RawExit : returns

    RawExit --> RoomIdSet : outgoing

    Shard --> mutex : contains

    thread_utils --> ProgressCounter : uses
    thread_utils --> std_thread : hardware_concurrency

    class std_thread {
        +hardware_concurrency() unsigned int
    }